
class cScene(object):

    """
     Escena autosuficiente capaz de ejecutarse en el motor, responder a la entrada
     del usuario y genera una salida por pantalla adecuada. Una escena esta formada
     por los recursos (resources) y las capas (layers).

    :version:
    :author:
    """

    """ ATTRIBUTES

     Id asignado a la escena.

    id  (public)

     Diccionario de capas que componen la escena.

    layers  (public)

     Diccionario con las capas activas. Solo se actualizaran y dibujaran en pantallas
     las capas que se encuentren en este diccionario.

    active_layers  (public)

     Conjunto de recursos disponibles para esta escena.

    resources  (public)

     Indica si las escena ha sido cargada.

    loaded  (public)

     Referencia al motor del juego en el que se encuentra cargada esta escena.

    engine  (public)

     Gestor de red.

    network_manager  (public)

     Objeto espacio fisico de la libreria pymunk. Gestiona la fisica de todos los
     objetos añadidos a el.

    space  (public)

     Cola de mensajes recibidos. Se procesan en cada actualizacion.

    message_queue  (public)

    """

    def __init__(self):
        """
         

        @return  :
        @author
        """
        pass

    def load(self, self, scene_config):
        """
         Carga la informacion necesaria para la escena. Principalmente los recursos que
         deben estar disponibles.

        @param cScene self : 
        @param string scene_config : Texto con la configuracion necesaria para la carga de la escena. Normalmente la direccion de la configuracion del archivo de recursos.
        @return  :
        @author
        """
        pass

    def add_layer(self, self, layer):
        """
         Añade una capa a la lista de capas disponibles en la escena. Devuelve el id que
         ha recibido la capa.

        @param cScene self : 
        @param cLayer layer : Capa que se añade a la escena.
        @return int :
        @author
        """
        pass

    def get_layer(self, self, layer_id):
        """
         Obtiene una capa de la lista de capas disponibles en la escena.

        @param cScene self : 
        @param int layer_id : Id de la capa que se quiere obtener.
        @return cLayer :
        @author
        """
        pass

    def remove_layer(self, self, layer_id):
        """
         Retira una capa de la lista de capas disponibles.

        @param cScene self : 
        @param int layer_id : Id de la capa que se quiere retirar.
        @return  :
        @author
        """
        pass

    def show_layer(self, self, layer_id):
        """
         Añade una capa a la lista de capas que se actualizan y dibujan. A la hora de
         añadir la capa, tiene en cuenta la propiedad "zindex" de la capa de forma que
         haya un control sobre que capas se dibujan sobre otras. Las capas con un zindex
         mas bajo se dibujan primer, mientras que las que tienen un zindex mas alto se
         dibujan mas tarde. Ej:
         fondo -> zindex = -1
         elementos -> zindex = 0
         interfaz -> zindex = 1
         menus -> zindex = 2
         mensajes -> zindex = 3

        @param cScene self : 
        @param int layer_id : Id de la capa que se quiere mostrar.
        @return  :
        @author
        """
        pass

    def hide_layer(self, self, layer_id):
        """
         Retira una capa de la lista de capas que se actualizan y dibujan.

        @param cScene self : 
        @param int layer_id : Id de la capa que se quiere dejar de mostrar.
        @return  :
        @author
        """
        pass

    def update(self, self, elapsed, keyboard, mouse):
        """
         Actualiza las capas de la lista "active_layers" pasandoles la informacion del
         tiempo transcurrido desde la ultima actualizacion, el estado actual del teclado
         y el estado actual del raton. Ademas, actualiza el estado del espacio fisico
         para que se actualicen las velocidades, posiciones y colisiones de los objetos.
         Tambien recorre la lista de mensajes para procesar los recibidos.

        @param cScene self : 
        @param float elapsed : 
        @param cKeyboard keyboard : 
        @param cMouse mouse : 
        @return  :
        @author
        """
        pass

    def render(self, self):
        """
         Ejecuta el render de las capas que se encuentran en la lista de las capas a
         dibujar "active_layers".

        @param cScene self : 
        @return  :
        @author
        """
        pass

    def process_message(self, self, message):
        """
         Procesa un mensaje recibido. Los mensajes normalmente llegan por la red, aunque
         se pueden mandar de forma manual para simular un comportamiento determinado o
         realizar demos, presentaciones, etc...

        @param cScene self : 
        @param cMessage message : Mensaje recibo para procesar.
        @return  :
        @author
        """
        pass



